package com.wtb.javatool.service.impl;

import com.wtb.javatool.common.PageBean;
import com.wtb.javatool.dao.ProjectCourseMapper;
import com.wtb.javatool.dao.ProjectMapper;
import com.wtb.javatool.dao.ProjectUserMapper;
import com.wtb.javatool.dto.ProjectDto;
import com.wtb.javatool.dto.TeamDto;
import com.wtb.javatool.dto.UserDto;
import com.wtb.javatool.entity.Course;
import com.wtb.javatool.entity.Project;
import com.wtb.javatool.service.ProjectService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.*;
import java.util.stream.Collectors;

@Service
public class ProjectServiceImpl implements ProjectService {
    private final ProjectMapper projectMapper;
    private final ProjectUserMapper projectUserMapper;
    private final ProjectCourseMapper projectCourseMapper;

    @Autowired
    public ProjectServiceImpl(ProjectMapper projectMapper, ProjectUserMapper projectUserMapper, ProjectCourseMapper projectCourseMapper) {
        this.projectMapper = projectMapper;
        this.projectUserMapper = projectUserMapper;
        this.projectCourseMapper = projectCourseMapper;
    }


    /**
     * 创建项目 并关联其相关负责人。
     *
     * @param project     项目实体，必须包含有效的项目信息。
     * @param userIds     项目相关负责人的用户ID列表，不能为空且必须包含有效的用户ID。
     * @param projectType 项目类型。
     * @return 插入到项目-用户关联表中的条数，即成功添加的相关负责人数量。
     */
    public int createProject(Project project, List<Long> userIds, Integer projectType) {

        // 插入项目基本信息
        projectMapper.createProject(project);
        if (projectType ==1){
            return projectUserMapper.addProjectLeaders(project.getProjectId(), userIds);
        }else{

            return projectUserMapper.batchInsertProjectManager(project.getProjectId(),userIds);
        }

    }


    /**
     * 查询所有项目
     *
     * @param userId        用户id，用于筛选于自己相关的项目
     * @param projectName   项目名称
     * @param projectDate   项目日期，用户查找在日期范围内的具体项目
     * @param projectType   项目类型
     * @param projectStatus 项目状态
     * @param currentPage   当前页数
     * @param pageSize      每页大小
     * @return 带分页器的项目列表
     */
    public PageBean<Project> findProjectsByUserId(Long userId, String projectName, Integer projectType, Integer projectStatus, List<Long> projectDate, Integer currentPage, Integer pageSize) {
        Long start = null;
        Long end = null;
        if (!projectDate.isEmpty()) {
            start = projectDate.get(0);
            end = projectDate.get(1);
        }

        List<Project> projects = projectMapper.findProjectsByUserId(userId, projectName, projectType, projectStatus, start, end, currentPage * pageSize, pageSize);

        Integer count = projectMapper.findProjectsByUserIdCount(userId, projectName, projectType, projectStatus, start, end);
        PageBean<Project> pageBean = new PageBean<>();
        pageBean.setRows(projects);
        pageBean.setTotalCount(count);
        return pageBean;
    }


    /**
     * 根据项目ID来检索项目基本信息与课程信息和人员信息。
     *
     * @param projectId   - 项目ID
     * @param projectType - 项目类型，用于区分项目式教学项目于普通项目
     * @return 返回项目基本信息
     */
    public ProjectDto findProjectByProjectId(Long projectId, int projectType) {

        if (projectType == 1) {//普通项目
            return projectMapper.findNormalProjectByProjectId(projectId);
        } else { //项目式教学项目
            return projectMapper.findTeachingProjectByProjectId(projectId);
        }
    }


    /**
     * 根据项目ID、用户名称（可选）查询项目用户成员。
     *
     * @param projectId 项目ID，用于检索该项目。
     * @param userName  用户名称，用于筛选查询结果（可为null或空字符串表示不筛选）。
     * @return 返回满足条件的对象列表。
     */
    public List<UserDto> findProjectMemberByProjectId(Long projectId, String userName) {

        return projectUserMapper.findNormalProjectMemberByProjectId(projectId, userName);

    }

    public List<TeamDto> findProjectTeamsAndMembersByProjectId(Long projectId,Long courseId) {

        return projectUserMapper.findProjectTeamsAndMembersByProjectId(projectId,courseId);

    }

    /**
     * 增删查改某个项目中的成员信息。
     *
     * @param projectId     项目ID，用于确定唯一项目。
     * @param frontendUsers 用户列表，该用户列表为当前项目的全部用户信息。。
     */
    public void upsertDeleteUsers(Long projectId, List<UserDto> frontendUsers) {
        List<UserDto> backendUsers = projectUserMapper.findNormalProjectMemberByProjectId(projectId, null);

        // 用于存储需要删除的用户ID
        Set<Long> backendUserIds = backendUsers.stream()
                .map(UserDto::getUserId)
                .collect(Collectors.toSet());

        // 遍历前端用户列表进行更新和插入
        for (UserDto frontendUser : frontendUsers) {
            Optional<UserDto> existingUser = backendUsers.stream()
                    .filter(u -> u.getUserId().equals(frontendUser.getUserId()))
                    .findFirst();
            if (existingUser.isPresent()) {
                // 更新用户（这里假设只要ID相同就认为是同一个用户，然后根据需要比较属性）
                // 注意：这里应该有一个更详细的属性比较逻辑
                projectUserMapper.updateUser(projectId, frontendUser);
                // 从需要删除的ID集合中移除已更新的用户ID
                backendUserIds.remove(frontendUser.getUserId());
            } else {
                // 插入新用户
                projectUserMapper.insertUser(projectId, frontendUser);
            }
        }
        // 删除后端中存在但前端中没有的用户
        for (Long userId : backendUserIds) {
            projectUserMapper.deleteUserById(projectId, userId);
        }
    }

    /**
     * 更新某个项目的信息（包括：名称、描述、状态、开始和结束时间）。
     *
     * @param project 项目实体。
     */
    public void updateProject(Project project) {
        projectMapper.updateProject(project);
    }

    /**
     * 增删某个项目与课程的关联。
     *
     * @param projectId       项目ID，用于确定唯一项目。
     * @param frontendCourses 课程列表，该课程列表包含课程号和课程名称。
     */
    public void upsertDeleteCourses(Long projectId, List<Course> frontendCourses) {
        List<Course> backendCourses = projectCourseMapper.findProjectCourseByProjectId(projectId);

        // 用于存储需要删除的课程ID
        Set<Long> backendCourseIds = backendCourses.stream()
                .map(Course::getCourseId)
                .collect(Collectors.toSet());

        // 遍历前端课程列表进行插入
        for (Course frontendCourse : frontendCourses) {
            Optional<Course> existingUser = backendCourses.stream()
                    .filter(c -> c.getCourseId().equals(frontendCourse.getCourseId()))
                    .findFirst();
            if (existingUser.isPresent()) {
                backendCourseIds.remove(frontendCourse.getCourseId());
            } else
                // 插入新课程
                projectCourseMapper.insertCourse(projectId, frontendCourse);
        }
        // 删除后端中存在但前端中没有的课程
        for (Long courseId : backendCourseIds) {
            projectCourseMapper.deleteCourseByCourseId(projectId, courseId);
        }
    }
}
